package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.base.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;


import com.wicket.okrcomponent.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.MOmsExecuteCycleStageService;
import com.wicket.okrapp.dal.po.mbg.OmsExecuteCycleStage;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.base.service.MOmsTspeCycleStageDataService;
import com.wicket.okrapp.dal.po.mbg.OmsTspeCycleStageData;
import com.wicket.okrapp.biz.service.nb.NbExecuteCycle;
import com.wicket.okrapp.base.service.MOmsCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsCycle;
import com.wicket.okrapp.biz.service.dto.common.ExecuteCycleStageDto;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrapp.biz.service.CycleStageDataService;

import java.util.ArrayList;
import com.wicket.okrapp.biz.service.GridCalculateService;
import com.wicket.okrapp.base.service.MOmsTaskService;
import com.wicket.okrapp.biz.service.CustomExecutionCycleService;
import com.wicket.okrapp.biz.service.TargetCalcService;
import com.wicket.okrapp.biz.service.TargetCycleService;

/**
 * @author ：
 * @date ：
 * 
 *
 * @version 1.0
 */
@Service
public class ExecuteCycleServiceImpl
  implements com.wicket.okrapp.biz.service.ExecuteCycleService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
//@Resource
 //private MCustomFields3Service mCustomFields3Service;
@Resource
  private MOmsTspeCycleStageDataService mOmsTspeCycleStageDataService;
@Resource
  private NbExecuteCycle nbExecuteCycle;
@Resource
  private MOmsCycleService mOmsCycleService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private CycleStageDataService cycleStageDataService;
@Resource
  private GridCalculateService gridCalculateService;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private CustomExecutionCycleService customExecutionCycleService;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private TargetCycleService targetCycleService;
/**
   * D3-执行周期回写目标周期ID(公共)[6707]
   * gen by moon at 5/22/2023, 3:48:20 AM
   */
  @Trace(operationName = "D3-执行周期回写目标周期ID(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementExecuteCycleWriteBackEvaObjectCycleIdComRespDto implementExecuteCycleWriteBackEvaObjectCycleIdCom(ImplementExecuteCycleWriteBackEvaObjectCycleIdComReqDto reqDto){
    
      
      if((reqDto!= null&&  reqDto.getIsProcessCycleStage() !=null && reqDto.getIsProcessCycleStage().equals("FALSE"))) {
        //if(D3-执行周期回写目标周期ID(公共).是否过程周期阶段 等于 否)  41767
        
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:944277_1_41769
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:944279_1_41769
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:944275_1_41769
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:944272_1_41769
queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:944273_1_41769
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:944274_1_41769
    }
  
    /*3-3-09查被评对象目标周期详情（通过周期ID）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(),"D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行周期回写目标周期ID(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
boolean bOOLEAN ;
    if(omsEvaluationObjectTargetCycle !=null){
          OmsExecuteCycleStage omsExecuteCycleStage=new OmsExecuteCycleStage();
  if(reqDto!=null){
      omsExecuteCycleStage.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:943410_1_41770
    }
if(omsEvaluationObjectTargetCycle!=null){
      omsExecuteCycleStage.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:943411_1_41770
    }
  
    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage.getExecuteCycleStageId(),"D3-执行周期回写目标周期ID(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
Assert.isNull(omsExecuteCycleStage.getEvaObjTargetCycleId(),"D3-执行周期回写目标周期ID(公共)-3-3-07修改执行周期阶段-被评对象目标周期ID不能为空",false);
      bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
      }
else if((reqDto!= null&&  reqDto.getIsProcessCycleStage() !=null && reqDto.getIsProcessCycleStage().equals("TRUE"))){
       //elseif(D3-执行周期回写目标周期ID(公共).是否过程周期阶段 等于 是)  41768
      
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryTargetCycleByStartAndEndTimeDetailReq queryTargetCycleByStartAndEndTimeDetailReq=new QueryTargetCycleByStartAndEndTimeDetailReq();
  queryTargetCycleByStartAndEndTimeDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:944253_1_41771
queryTargetCycleByStartAndEndTimeDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:944254_1_41771
queryTargetCycleByStartAndEndTimeDetailReq.setIsSubCycle("TRUE");//sourceId:944256_1_41771
queryTargetCycleByStartAndEndTimeDetailReq.setIsArchive("FALSE");//sourceId:944261_1_41771
if(reqDto!=null){
      queryTargetCycleByStartAndEndTimeDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:944255_1_41771
queryTargetCycleByStartAndEndTimeDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:944257_1_41771
queryTargetCycleByStartAndEndTimeDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:944258_1_41771
queryTargetCycleByStartAndEndTimeDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:944259_1_41771
    }
  
    /*3-3-09查目标子周期By开始与结束时间[6551]   */
    Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaObjEntityId(),"D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaObjTypeCode(),"D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getTargetCycleContentId(),"D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-关联目标内容ID不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getIsSubCycle(),"D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-是否子周期不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getCycleStartTime(),"D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-目标计划开始时间不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getCycleEndTime(),"D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-目标计划结束时间不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaluationTemplateId(),"D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getIsArchive(),"D3-执行周期回写目标周期ID(公共)-3-3-09查目标子周期By开始与结束时间-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryTargetCycleByStartAndEndTimeDetail(queryTargetCycleByStartAndEndTimeDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
boolean bOOLEAN_1 ;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_1=new OmsExecuteCycleStage();
  if(reqDto!=null){
      omsExecuteCycleStage_1.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:943410_1_41772
    }
if(omsEvaluationObjectTargetCycle_2!=null){
      omsExecuteCycleStage_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:943411_1_41772
    }
  
    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_1.getExecuteCycleStageId(),"D3-执行周期回写目标周期ID(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_1.getEvaObjTargetCycleId(),"D3-执行周期回写目标周期ID(公共)-3-3-07修改执行周期阶段-被评对象目标周期ID不能为空",false);
      bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_1)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    }
ImplementExecuteCycleWriteBackEvaObjectCycleIdComRespDto retData = new ImplementExecuteCycleWriteBackEvaObjectCycleIdComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-查询执行周期详情（开始小于等于&结束大于等于）(公共)[7282]
   * gen by moon at 7/13/2023, 4:22:08 AM
   */
  @Trace(operationName = "D3-查询执行周期详情（开始小于等于&结束大于等于）(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryExecuteCycleLessStartBIgEndDetailComRespDto queryExecuteCycleLessStartBIgEndDetailCom(QueryExecuteCycleLessStartBIgEndDetailComReqDto reqDto){


      OmsExecuteCycleStage omsExecuteCycleStage_1 =null;
//步骤0: 3-3-07-查执行周期时间详情（开始小于等于&结束大于等于） - queryExecuteCycleLessStartBIgEndDetail
     OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleLessStartBIgEndDetailReq queryExecuteCycleLessStartBIgEndDetailReq=new QueryExecuteCycleLessStartBIgEndDetailReq();
  if(reqDto!=null){
      queryExecuteCycleLessStartBIgEndDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1074098_1
queryExecuteCycleLessStartBIgEndDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1074099_1
queryExecuteCycleLessStartBIgEndDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1074100_1
queryExecuteCycleLessStartBIgEndDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1074101_1
queryExecuteCycleLessStartBIgEndDetailReq.setIsFatherCycle(reqDto.getIsFatherCycle());//SimpleFieldAssign//sourceId:1074102_1
queryExecuteCycleLessStartBIgEndDetailReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1074103_1
queryExecuteCycleLessStartBIgEndDetailReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1074104_1
queryExecuteCycleLessStartBIgEndDetailReq.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1074105_1
queryExecuteCycleLessStartBIgEndDetailReq.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1074106_1
queryExecuteCycleLessStartBIgEndDetailReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1074107_1
queryExecuteCycleLessStartBIgEndDetailReq.setRelateContentId(reqDto.getRelateContentId());//SimpleFieldAssign//sourceId:1074108_1
queryExecuteCycleLessStartBIgEndDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1074109_1
queryExecuteCycleLessStartBIgEndDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1074110_1
queryExecuteCycleLessStartBIgEndDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1074111_1
    }

    /*3-3-07-查执行周期时间详情（开始小于等于&结束大于等于）[7281]   */

      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleLessStartBIgEndDetail(queryExecuteCycleLessStartBIgEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsExecuteCycleStage_1 = omsExecuteCycleStage;

QueryExecuteCycleLessStartBIgEndDetailComRespDto retData = new QueryExecuteCycleLessStartBIgEndDetailComRespDto();
  if(omsExecuteCycleStage_1!=null){
      retData.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1074128_1
retData.setCycleId(omsExecuteCycleStage_1.getCycleId());//SimpleFieldAssign//sourceId:1074129_1
retData.setCycleTypeCode(omsExecuteCycleStage_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1085694_1
    }




return retData;
  }
/**
   * D3-执行更新周期时间切片分析(公共)[7293]
   * gen by moon at 7/20/2023, 4:34:44 PM
   */
  @Trace(operationName = "D3-执行更新周期时间切片分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUpdateCycleTimeSliceAnalyzeComRespDto implementUpdateCycleTimeSliceAnalyzeCom(ImplementUpdateCycleTimeSliceAnalyzeComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
//virtualUsage 3-3-11查周期阶段资料详情  47764
     OmsTspeCycleStageData omsTspeCycleStageData = null;
    QueryCycleStageDataDetailReq queryCycleStageDataDetailReq=new QueryCycleStageDataDetailReq();
  queryCycleStageDataDetailReq.setCycleDataObjTypeCode("EVA_OBJ_TARGET_CYCLE");//sourceId:1082769_1_47764
queryCycleStageDataDetailReq.setStageContentType("STA_WOR_SUM_CON");//sourceId:1082767_1_47764
queryCycleStageDataDetailReq.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1082768_1_47764
queryCycleStageDataDetailReq.setIsArchive("FALSE");//sourceId:1082772_1_47764
if(reqDto!=null){
      queryCycleStageDataDetailReq.setCycleDataObjId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1082770_1_47764
queryCycleStageDataDetailReq.setCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1082766_1_47764
queryCycleStageDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1082776_1_47764
    }

    /*3-3-11查周期阶段资料详情[2771]   */
    Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjId(),"D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-周期资料归属对象ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjTypeCode(),"D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-周期资料归属对象类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleId(),"D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-周期ID不能为空",false);
    Assert.isNull(queryCycleStageDataDetailReq.getStageContentType(),"D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-内容性质类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleDataTypeCode(),"D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-周期阶段资料类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getIsArchive(),"D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-是否存档不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getThemeContentId(),"D3-执行更新周期时间切片分析(公共)-3-3-11查周期阶段资料详情-主题内容ID不能为空",false);
      omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTspeCycleStageData != null )) {
        //if(3-3-11查周期阶段资料详情.出参 值不等于空 )  47765

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(omsTspeCycleStageData !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(omsTspeCycleStageData!=null){
      receptionServiceReq.setWorkCycleUpdateSlice(omsTspeCycleStageData.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1092139_1_47766
    }

    /*M3-约定出参：工作周期更新切片[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getWorkCycleUpdateSlice(),"D3-执行更新周期时间切片分析(公共)-M3-约定出参：工作周期更新切片-工作周期更新切片不能为空",false);
      receptionServiceRes = nbExecuteCycle.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((omsTspeCycleStageData == null )){
       //elseif(3-3-11查周期阶段资料详情.出参 值等于空 )  47767

ImplementAnalyseWorkCycleUpdateSliceComRespDto implementAnalyseWorkCycleUpdateSliceComRespDto = null;
    ImplementAnalyseWorkCycleUpdateSliceComReqDto implementAnalyseWorkCycleUpdateSliceComReqDto=new ImplementAnalyseWorkCycleUpdateSliceComReqDto();
  if(reqDto!=null){
      implementAnalyseWorkCycleUpdateSliceComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1092143_1_47768
implementAnalyseWorkCycleUpdateSliceComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1092144_1_47768
implementAnalyseWorkCycleUpdateSliceComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1092142_1_47768
implementAnalyseWorkCycleUpdateSliceComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1092145_1_47768
    }

    /*D3-执行分析工作周期更新切片（公共）[6275]   */
    Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getEvaObjTargetCycleId(),"D3-执行更新周期时间切片分析(公共)-D3-执行分析工作周期更新切片（公共）-被评对象目标周期ID不能为空",false);
Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getParentSubMidCycleType(),"D3-执行更新周期时间切片分析(公共)-D3-执行分析工作周期更新切片（公共）-父子中周期类型不能为空",false);
Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getCycleStartTime(),"D3-执行更新周期时间切片分析(公共)-D3-执行分析工作周期更新切片（公共）-目标计划开始时间不能为空",false);
Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getCycleEndTime(),"D3-执行更新周期时间切片分析(公共)-D3-执行分析工作周期更新切片（公共）-目标计划结束时间不能为空",false);
      implementAnalyseWorkCycleUpdateSliceComRespDto = cycleStageDataService.implementAnalyseWorkCycleUpdateSliceCom(implementAnalyseWorkCycleUpdateSliceComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(implementAnalyseWorkCycleUpdateSliceComRespDto !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(implementAnalyseWorkCycleUpdateSliceComRespDto!=null){
      receptionServiceReq_1.setWorkCycleUpdateSlice(implementAnalyseWorkCycleUpdateSliceComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1092139_1_47769
    }

    /*M3-约定出参：工作周期更新切片[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getWorkCycleUpdateSlice(),"D3-执行更新周期时间切片分析(公共)-M3-约定出参：工作周期更新切片-工作周期更新切片不能为空",false);
      receptionServiceRes_2 = nbExecuteCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
ImplementUpdateCycleTimeSliceAnalyzeComRespDto retData = new ImplementUpdateCycleTimeSliceAnalyzeComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setWorkCycleUpdateSlice(receptionServiceRes_1.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1092147_1
    }




return retData;
  }
/**
   * D3-执行相同周期类型当前及历史周期(公共)[7295]
   * gen by moon at 7/12/2023, 6:25:44 PM
   */
  @Trace(operationName = "D3-执行相同周期类型当前及历史周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCurrentAndHistoryCycleOfSameCycleTypeComRespDto implementCurrentAndHistoryCycleOfSameCycleTypeCom(ImplementCurrentAndHistoryCycleOfSameCycleTypeComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
//virtualUsage 3-4-04查询周期详情  47473
      OmsCycle omsCycle = null;
    QueryCycleDetailReq queryCycleDetailReq=new QueryCycleDetailReq();
  queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1085427_1_47473
if(reqDto!=null){
      queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1085426_1_47473
    }

    /*3-4-04查询周期详情[2004]   */
    Assert.isNull(queryCycleDetailReq.getCycleId(),"D3-执行相同周期类型当前及历史周期(公共)-3-4-04查询周期详情-周期ID不能为空",false);
Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(),"D3-执行相同周期类型当前及历史周期(公共)-3-4-04查询周期详情-主体生命周期不能为空",false);
      omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D2执行根据排序左右切数据(公共)  47472
      ImplementSplitDataBySortComRespDto implementSplitDataBySortComRespDto = null;
    if(omsCycle !=null){
          ImplementSplitDataBySortComReqDto implementSplitDataBySortComReqDto=new ImplementSplitDataBySortComReqDto();
  implementSplitDataBySortComReqDto.setCustomField1("FIND_BIG_DATA");//CUSTOM_CONVENTION//sourceId:1085169_1_47472
if(reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())){
      implementSplitDataBySortComReqDto.setComDatasList(//objList-to-objLists
        reqDto.getExecuteCycleStageList().stream().map(item -> {
      ComDatasDto elm = new ComDatasDto();
      if(item!=null){
      elm.setCommPrimaryKey(item.getCycleId());//SimpleFieldAssign//sourceId:228530_2_47472
elm.setCustomField2(item.getOrderNumber()!=null?String.valueOf(item.getOrderNumber()):"");//SimpleFieldAssign//sourceId:228532_2_47472
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1085168_1_47472
    }
if(omsCycle!=null){
      implementSplitDataBySortComReqDto.setCustomField2(omsCycle.getOrderNumber()!=null?String.valueOf(omsCycle.getOrderNumber()):"");//SimpleFieldAssign//sourceId:1085170_1_47472
    }

    /*D2执行根据排序左右切数据(公共)[5866]   */
    Assert.isNull(implementSplitDataBySortComReqDto.getCustomField1(),"D3-执行相同周期类型当前及历史周期(公共)-D2执行根据排序左右切数据(公共)-区间找数据策略不能为空",false);
Assert.isNull(implementSplitDataBySortComReqDto.getCustomField2(),"D3-执行相同周期类型当前及历史周期(公共)-D2执行根据排序左右切数据(公共)-自定义字段2不能为空",false);
      implementSplitDataBySortComRespDto = fwCompInterfaceModeClient.implementSplitDataBySortCom(implementSplitDataBySortComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D2执行数据集加一条记录(公共)  47474
      ImplementDataSetPlusOneComRespDto implementDataSetPlusOneComRespDto = null;
    if(implementSplitDataBySortComRespDto !=null){
          ImplementDataSetPlusOneComReqDto implementDataSetPlusOneComReqDto=new ImplementDataSetPlusOneComReqDto();
  if(implementSplitDataBySortComRespDto!= null&&  implementSplitDataBySortComRespDto.getComDatasList() !=null&& !CollectionUtil.isEmpty(implementSplitDataBySortComRespDto.getComDatasList())){
      implementDataSetPlusOneComReqDto.setDataSetPlusOneList(implementSplitDataBySortComRespDto.getComDatasList().stream().map(item->item.getCommPrimaryKey())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1085423_1_47474
    }
if(reqDto!=null){
      implementDataSetPlusOneComReqDto.setCommPrimaryKey(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1085424_1_47474
    }

    /*D2执行数据集加一条记录(公共)[5161]   */
    Assert.isNull(implementDataSetPlusOneComReqDto.getCommPrimaryKey(),"D3-执行相同周期类型当前及历史周期(公共)-D2执行数据集加一条记录(公共)-通用主键ID不能为空",false);
      implementDataSetPlusOneComRespDto = fwCompInterfaceModeClient.implementDataSetPlusOneCom(implementDataSetPlusOneComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage 出参数据集：执行周期阶段列表  47476
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(implementDataSetPlusOneComRespDto !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(implementDataSetPlusOneComRespDto!=null){
      //simpleList-to-objLists
    for (String item : implementDataSetPlusOneComRespDto.getDataSetPlusOneList()) {
                ExecuteCycleStageDto oneItem = new ExecuteCycleStageDto();
                if(implementDataSetPlusOneComRespDto!=null){
      oneItem.setCycleId(item);//SimpleFieldAssign//sourceId:228668_2_47476
    }

                receptionServiceReq.getExecuteCycleStageList().add(oneItem);
            }//sourceId:1085655_1_47476
    }

    /*出参数据集：执行周期阶段列表[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbExecuteCycle.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
ImplementCurrentAndHistoryCycleOfSameCycleTypeComRespDto retData = new ImplementCurrentAndHistoryCycleOfSameCycleTypeComRespDto();
  if(receptionServiceRes_1!= null&&  receptionServiceRes_1.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(receptionServiceRes_1.getExecuteCycleStageList())){
      retData.setExecuteCycleStageList(receptionServiceRes_1.getExecuteCycleStageList().stream().map(item->item.getCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1085657_1
    }




return retData;
  }
/**
   * D3-查询最近可循环最大执行周期详情(公共)[7498]
   * gen by moon at 10/8/2023, 12:50:06 PM
   */
  @Trace(operationName = "D3-查询最近可循环最大执行周期详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryNextCycleMaxPeriodDetailComRespDto queryNextCycleMaxPeriodDetailCom(QueryNextCycleMaxPeriodDetailComReqDto reqDto){


      ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_1 =null;
if((reqDto!= null&& reqDto.getNextCyclePeriod() != null )) {
        //if(D3-查询最近可循环最大执行周期详情(公共).最近可循环周期类型编码 值不等于空 )  49683

      List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
          QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq=new QuerySubCycleExecuteCycleStageListReq();
  querySubCycleExecuteCycleStageListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1162302_1_49685
if(reqDto!=null){
      querySubCycleExecuteCycleStageListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1162298_1_49685
      querySubCycleExecuteCycleStageListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1162299_1_49685
querySubCycleExecuteCycleStageListReq.setCycleTypeCode(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1162300_1_49685
querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1162301_1_49685
    }

    /*3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）[4718]   */
    Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleStartTime(),"D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(),"D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleTypeCode(),"D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期类型标识不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(),"D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getSubjectLifeCycle(),"D3-查询最近可循环最大执行周期详情(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-主体生命周期不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsExecuteCycleStage!= null&&  listOmsExecuteCycleStage !=null && listOmsExecuteCycleStage.size()>0)) {
        //if(3-3-07查时间范围内周或双周列表.执行周期阶段列表数据集条数 大于 0)  49690

ImplementDataListGetMaxOrMiniByOrderNumberComRespDto implementDataListGetMaxOrMiniByOrderNumberComRespDto = null;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          ImplementDataListGetMaxOrMiniByOrderNumberComReqDto implementDataListGetMaxOrMiniByOrderNumberComReqDto=new ImplementDataListGetMaxOrMiniByOrderNumberComReqDto();
  implementDataListGetMaxOrMiniByOrderNumberComReqDto.setOrderSizeType("FROM_SMALL_LARGE");//sourceId:1162312_1_49691
if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      implementDataListGetMaxOrMiniByOrderNumberComReqDto.setComDatasList(//objList-to-objLists
        listOmsExecuteCycleStage.stream().map(item -> {
      ComDatasDto elm = new ComDatasDto();
      elm.setCustomField(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:241848_2_49691
elm.setCustomField1(item.getCycleId());//SimpleFieldAssign//sourceId:241853_2_49691
elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:241849_2_49691
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1162313_1_49691
    }

    /*D2-执行数据集根据排序字段取最大最小(公共)[7500]   */
    Assert.isNull(implementDataListGetMaxOrMiniByOrderNumberComReqDto.getOrderSizeType(),"D3-查询最近可循环最大执行周期详情(公共)-D2-执行数据集根据排序字段取最大最小(公共)-排序大小类型不能为空",false);
      implementDataListGetMaxOrMiniByOrderNumberComRespDto = fwCompInterfaceModeClient.implementDataListGetMaxOrMiniByOrderNumberCom(implementDataListGetMaxOrMiniByOrderNumberComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
    if(implementDataListGetMaxOrMiniByOrderNumberComRespDto !=null){
          ImplementAcceptFieldByStandardDataReqDto receptionServiceReq=new ImplementAcceptFieldByStandardDataReqDto();
  if(implementDataListGetMaxOrMiniByOrderNumberComRespDto!=null){
      receptionServiceReq.setExecuteCycleStageId(implementDataListGetMaxOrMiniByOrderNumberComRespDto.getCustomField());//SimpleFieldAssign//sourceId:1162326_1_49692
receptionServiceReq.setCycleId(implementDataListGetMaxOrMiniByOrderNumberComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1162337_1_49692
    }

    /*约定出参：执行周期ID，周期ID[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getExecuteCycleStageId(),"D3-查询最近可循环最大执行周期详情(公共)-约定出参：执行周期ID，周期ID-执行周期阶段ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleId(),"D3-查询最近可循环最大执行周期详情(公共)-约定出参：执行周期ID，周期ID-周期ID不能为空",false);
      receptionServiceRes = nbExecuteCycle.implementAcceptFieldByStandardData(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
      }
else{
       //else  49684

//异常结束 49687
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
QueryNextCycleMaxPeriodDetailComRespDto retData = new QueryNextCycleMaxPeriodDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setExecuteCycleStageId(receptionServiceRes_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1162328_1
retData.setCycleId(receptionServiceRes_1.getCycleId());//SimpleFieldAssign//sourceId:1162341_1
    }




return retData;
  }
/**
   * D3获取当前目标内容执行周期(公共)[7501]
   * gen by moon at 5/7/2024, 11:20:15 PM
   */
  @Trace(operationName = "D3获取当前目标内容执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleCom(ObtainCurrentTargetContexeCuteCycleComReqDto reqDto){


      OmsExecuteCycleStage omsExecuteCycleStage_1 =null;
//virtualUsage 3-3-07查目标内容执行周期  49654
      OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1162663_1_49654
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1162495_1_49654
queryExecuteCycleStageDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1162496_1_49654
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1162498_1_49654
    }

    /*3-3-07查目标内容执行周期[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(),"D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-主体生命周期不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsExecuteCycleStage_1 = omsExecuteCycleStage;
if((omsExecuteCycleStage == null )) {
        //if(3-3-07查当前内容执行周期.出参 值等于空 )  49655

OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1162663_1_49656
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1162495_1_49656
queryExecuteCycleStageDetailReq_1.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1162496_1_49656
queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1162498_1_49656
    }

    /*3-3-07查目标内容执行周期[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_1.getCycleId(),"D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getRelateContentId(),"D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(),"D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getSubjectLifeCycle(),"D3获取当前目标内容执行周期(公共)-3-3-07查目标内容执行周期-主体生命周期不能为空",false);
      omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


      omsExecuteCycleStage_1 = omsExecuteCycleStage_2;
      }
ObtainCurrentTargetContexeCuteCycleComRespDto retData = new ObtainCurrentTargetContexeCuteCycleComRespDto();
  if(omsExecuteCycleStage_1!=null){
      retData.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1162501_1
retData.setLastExecuteCycleStageId(omsExecuteCycleStage_1.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1162502_1
retData.setRelateExecuteCycleStageId(omsExecuteCycleStage_1.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1162503_1
retData.setEvaObjTargetCycleId(omsExecuteCycleStage_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1162504_1
retData.setCycleId(omsExecuteCycleStage_1.getCycleId());//SimpleFieldAssign//sourceId:1162505_1
retData.setCycleStandardName(omsExecuteCycleStage_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1162506_1
retData.setCycleStartTime(omsExecuteCycleStage_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1162507_1
retData.setCycleEndTime(omsExecuteCycleStage_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1162508_1
retData.setFillStartTime(omsExecuteCycleStage_1.getFillStartTime());//SimpleFieldAssign//sourceId:1162509_1
retData.setFillEndtTime(omsExecuteCycleStage_1.getFillEndtTime());//SimpleFieldAssign//sourceId:1162510_1
retData.setIsFatherCycle(omsExecuteCycleStage_1.getIsFatherCycle());//SimpleFieldAssign//sourceId:1162511_1
retData.setIsSubCycle(omsExecuteCycleStage_1.getIsSubCycle());//SimpleFieldAssign//sourceId:1162512_1
retData.setEvaluationTemplateId(omsExecuteCycleStage_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1162513_1
retData.setCycleTypeCode(omsExecuteCycleStage_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1162514_1
retData.setRelateContentTypeCode(omsExecuteCycleStage_1.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1162515_1
retData.setRelateContentId(omsExecuteCycleStage_1.getRelateContentId());//SimpleFieldAssign//sourceId:1162516_1
retData.setTargetId(omsExecuteCycleStage_1.getTargetId());//SimpleFieldAssign//sourceId:1162517_1
retData.setIsMetaphase(omsExecuteCycleStage_1.getIsMetaphase());//SimpleFieldAssign//sourceId:1162518_1
retData.setIsProcessCycleStage(omsExecuteCycleStage_1.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1162519_1
retData.setIsDefinedExecuteCycleStage(omsExecuteCycleStage_1.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1162520_1
retData.setIsLastCycle(omsExecuteCycleStage_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1162522_1
retData.setEvaTempCreateTime(omsExecuteCycleStage_1.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1162523_1
retData.setIsCurrentCycle(omsExecuteCycleStage_1.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1162524_1
retData.setIsNextCycle(omsExecuteCycleStage_1.getIsNextCycle());//SimpleFieldAssign//sourceId:1162525_1
retData.setNextCyclePeriod(omsExecuteCycleStage_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1162526_1
retData.setEvaluateStartTime(omsExecuteCycleStage_1.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1162527_1
retData.setEvaluateEndtTime(omsExecuteCycleStage_1.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1162528_1
retData.setIsStartCycle(omsExecuteCycleStage_1.getIsStartCycle());//SimpleFieldAssign//sourceId:1162529_1
retData.setIsEndCycle(omsExecuteCycleStage_1.getIsEndCycle());//SimpleFieldAssign//sourceId:1162530_1
    }




return retData;
  }
/**
   * D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]
   * gen by moon at 10/26/2024, 7:39:46 PM
   */
  @Trace(operationName = "D3-查询上一个执行周期的周期及目标周期详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailCom(QueryLastExecCycleAndTargetCycleDetailComReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
QueryTargetContexeCuteCycleDetailComRespDto queryTargetContexeCuteCycleDetailComRespDto_1 =null;
ImplementAcceptFieldRespDto receptionServiceRes_1 =null;
//virtualUsage 3-3-09查被评对象目标周期详情（通过目标周期ID）  49766
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1166169_1_49766
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1166167_1_49766
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1166168_1_49766
    }

    /*3-3-09查被评对象目标周期详情（通过目标周期ID）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过目标周期ID）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过目标周期ID）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过目标周期ID）-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
//virtualUsage D3查询目标内容执行周期详情(公共)  69209
      QueryTargetContexeCuteCycleDetailComRespDto queryTargetContexeCuteCycleDetailComRespDto = null;
    QueryTargetContexeCuteCycleDetailComReqDto queryTargetContexeCuteCycleDetailComReqDto=new QueryTargetContexeCuteCycleDetailComReqDto();
  if(reqDto!=null){
      queryTargetContexeCuteCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1820389_1_69209
queryTargetContexeCuteCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1820387_1_69209
queryTargetContexeCuteCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1820388_1_69209
    }

    /*D3查询目标内容执行周期详情(公共)[9661]   */
    Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getCycleId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-D3查询目标内容执行周期详情(公共)-周期ID不能为空",false);
Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getEvaObjTargetCycleId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-D3查询目标内容执行周期详情(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getEvaluationTemplateId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-D3查询目标内容执行周期详情(公共)-冗余评价模板ID不能为空",false);
      queryTargetContexeCuteCycleDetailComRespDto = queryTargetContexeCuteCycleDetailCom(queryTargetContexeCuteCycleDetailComReqDto)/*vcase invoke 同服务,同domain*/;


      queryTargetContexeCuteCycleDetailComRespDto_1 = queryTargetContexeCuteCycleDetailComRespDto;
if((queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle().equals("TRUE")||queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase().equals("TRUE"))) {
        //if((D3查询目标内容执行周期详情(公共).是否父周期 等于 是 or D3查询目标内容执行周期详情(公共).是否中期 等于 是))  49770

//processBranchName:正常结束 ,processBranchId:49771

      }
else if((queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsSubCycle() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsSubCycle().equals("TRUE")&&queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle().equals("FALSE")&&queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase().equals("FALSE")&&queryTargetContexeCuteCycleDetailComRespDto!= null&& queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId() == null )){
       //elseif((D3查询目标内容执行周期详情(公共).是否子周期 等于 是 and D3查询目标内容执行周期详情(公共).是否父周期 等于 否 and D3查询目标内容执行周期详情(公共).是否中期 等于 否 and D3查询目标内容执行周期详情(公共).上一执行周期阶段ID 值等于空 ))  49772

//processBranchName:正常结束 ,processBranchId:49773

    }
else if((queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsSubCycle() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsSubCycle().equals("TRUE")&&queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsFatherCycle().equals("FALSE")&&queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsMetaphase().equals("FALSE")&&queryTargetContexeCuteCycleDetailComRespDto!= null&& queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId() != null )){
       //elseif((D3查询目标内容执行周期详情(公共).是否子周期 等于 是 and D3查询目标内容执行周期详情(公共).是否父周期 等于 否 and D3查询目标内容执行周期详情(公共).是否中期 等于 否 and D3查询目标内容执行周期详情(公共).上一执行周期阶段ID 值不等于空 ))  49774

OmsExecuteCycleStage omsExecuteCycleStage = null;
    if(queryTargetContexeCuteCycleDetailComRespDto !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1166673_1_49781
if(queryTargetContexeCuteCycleDetailComRespDto!=null){
      queryExecuteCycleStageDetailReq.setExecuteCycleStageId(queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1166671_1_49781
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1166672_1_49781
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-执行周期阶段ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    if(omsEvaluationObjectTargetCycle !=null&&omsExecuteCycleStage !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsSubCycle("TRUE");//sourceId:1166758_1_49783
queryEvaObjTargetCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1166760_1_49783
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1166753_1_49783
queryEvaObjTargetCycleDetailReq_1.setEvaObjTableTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:1166754_1_49783
queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1166755_1_49783
queryEvaObjTargetCycleDetailReq_1.setTreeTypeCode(omsEvaluationObjectTargetCycle.getTreeTypeCode());//SimpleFieldAssign//sourceId:1166756_1_49783
queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1166757_1_49783
    }
if(omsExecuteCycleStage!=null){
      queryEvaObjTargetCycleDetailReq_1.setCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:1166761_1_49783
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1166759_1_49783
    }

    /*3-3-09查被评对象目标周期详情（通过周期ID）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTableTypeCode(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象内容表类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTreeTypeCode(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-树类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getCycleId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsSubCycle(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getSubjectLifeCycle(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-09查被评对象目标周期详情（通过周期ID）-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    if(omsEvaluationObjectTargetCycle_2 !=null&&omsExecuteCycleStage !=null){
          ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(omsEvaluationObjectTargetCycle_2!=null){
      receptionServiceReq.setLastEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1166615_1_49776
    }
if(omsExecuteCycleStage!=null){
      receptionServiceReq.setLastCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:1166614_1_49776
    }

    /*约定出参：上一个执行周期-目标周期ID以及周期ID[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getLastEvaObjTargetCycleId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-约定出参：上一个执行周期-目标周期ID以及周期ID-上一周期被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getLastCycleId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-约定出参：上一个执行周期-目标周期ID以及周期ID-上一周期ID不能为空",false);
      receptionServiceRes = nbExecuteCycle.implementAcceptField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
    }
else if((queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsProcessCycleStage() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsProcessCycleStage().equals("TRUE")&&queryTargetContexeCuteCycleDetailComRespDto!= null&& queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId() == null )){
       //elseif((D3查询目标内容执行周期详情(公共).是否过程周期阶段 等于 是 and D3查询目标内容执行周期详情(公共).上一执行周期阶段ID 值等于空 ))  49777

//processBranchName:正常结束 ,processBranchId:49778

    }
else if((queryTargetContexeCuteCycleDetailComRespDto!= null&&  queryTargetContexeCuteCycleDetailComRespDto.getIsProcessCycleStage() !=null && queryTargetContexeCuteCycleDetailComRespDto.getIsProcessCycleStage().equals("TRUE")&&queryTargetContexeCuteCycleDetailComRespDto!= null&& queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId() != null )){
       //elseif((D3查询目标内容执行周期详情(公共).是否过程周期阶段 等于 是 and D3查询目标内容执行周期详情(公共).上一执行周期阶段ID 值不等于空 ))  49779

OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
    if(queryTargetContexeCuteCycleDetailComRespDto !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1166673_1_49784
if(queryTargetContexeCuteCycleDetailComRespDto!=null){
      queryExecuteCycleStageDetailReq_1.setExecuteCycleStageId(queryTargetContexeCuteCycleDetailComRespDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1166671_1_49784
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1166672_1_49784
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_1.getExecuteCycleStageId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-执行周期阶段ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getSubjectLifeCycle(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
      omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    if(omsExecuteCycleStage_2 !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setLastEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1166615_1_49780
    }
if(omsExecuteCycleStage_2!=null){
      receptionServiceReq_1.setLastCycleId(omsExecuteCycleStage_2.getCycleId());//SimpleFieldAssign//sourceId:1166614_1_49780
    }

    /*约定出参：上一个执行周期-目标周期ID以及周期ID[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getLastEvaObjTargetCycleId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-约定出参：上一个执行周期-目标周期ID以及周期ID-上一周期被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getLastCycleId(),"D3-查询上一个执行周期的周期及目标周期详情(公共)-约定出参：上一个执行周期-目标周期ID以及周期ID-上一周期ID不能为空",false);
      receptionServiceRes_2 = nbExecuteCycle.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
QueryLastExecCycleAndTargetCycleDetailComRespDto retData = new QueryLastExecCycleAndTargetCycleDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setLastEvaObjTargetCycleId(receptionServiceRes_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1166762_1
retData.setLastCycleId(receptionServiceRes_1.getLastCycleId());//SimpleFieldAssign//sourceId:1166763_1
    }
if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setParentEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024133_1
retData.setEvaObjEntityId(omsEvaluationObjectTargetCycle_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815758_1
retData.setEvaObjTypeCode(omsEvaluationObjectTargetCycle_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815759_1
retData.setTargetCycleId(omsEvaluationObjectTargetCycle_1.getCycleId());//SimpleFieldAssign//sourceId:1914696_1
    }
if(queryTargetContexeCuteCycleDetailComRespDto_1!=null){
      retData.setCycleStartTime(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1820425_1
retData.setCycleEndTime(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1820426_1
retData.setCycleTypeCode(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887547_1
retData.setNextCyclePeriod(queryTargetContexeCuteCycleDetailComRespDto_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1820428_1
retData.setIsLastCycle(queryTargetContexeCuteCycleDetailComRespDto_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1820427_1
    }




return retData;
  }
/**
   * D3执行过往执行周期是否末级处理(公共)[8774]
   * gen by moon at 4/30/2024, 2:33:07 AM
   */
  @Trace(operationName = "D3执行过往执行周期是否末级处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementWhetherPastExecutionPeriodIsLastDisposeComRespDto implementWhetherPastExecutionPeriodIsLastDisposeCom(ImplementWhetherPastExecutionPeriodIsLastDisposeComReqDto reqDto){


      if((reqDto!= null&& reqDto.getSecondLastCycleType() != null &&!(reqDto!= null&&  reqDto.getSecondLastCycleType() !=null && reqDto.getSecondLastCycleType().equals("DISABLE")))) {
        //if((D3执行过往执行周期是否末级处理(公共).第二末级周期类型 值不等于空  and D3执行过往执行周期是否末级处理(公共).第二末级周期类型 不等于 不启用))  64968

if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("IRREGULAR_CYCLE")||reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("SINGLE_CYCLE"))) {
        //if((D3执行过往执行周期是否末级处理(公共).周期模式类型编码 等于 不规则周期 or D3执行过往执行周期是否末级处理(公共).周期模式类型编码 等于 单周期))  64972

AnalysisReferenceTimeSecondCycleComRespDto analysisReferenceTimeSecondCycleComRespDto = null;
    AnalysisReferenceTimeSecondCycleComReqDto analysisReferenceTimeSecondCycleComReqDto=new AnalysisReferenceTimeSecondCycleComReqDto();
  analysisReferenceTimeSecondCycleComReqDto.setTargetCycleContentTypeCode("TARGET");//sourceId:1763768_1_67652
analysisReferenceTimeSecondCycleComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1763770_1_67652
if(reqDto!=null){
      analysisReferenceTimeSecondCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1763769_1_67652
    }

    /*D3分析第二末级周期场景裁减时间(公共)[9463]   */
    Assert.isNull(analysisReferenceTimeSecondCycleComReqDto.getTargetCycleContentTypeCode(),"D3执行过往执行周期是否末级处理(公共)-D3分析第二末级周期场景裁减时间(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(analysisReferenceTimeSecondCycleComReqDto.getEvaluationTemplateId(),"D3执行过往执行周期是否末级处理(公共)-D3分析第二末级周期场景裁减时间(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(analysisReferenceTimeSecondCycleComReqDto.getSpaceId(),"D3执行过往执行周期是否末级处理(公共)-D3分析第二末级周期场景裁减时间(公共)-创建于空间ID不能为空",false);
      analysisReferenceTimeSecondCycleComRespDto = customExecutionCycleService.analysisReferenceTimeSecondCycleCom(analysisReferenceTimeSecondCycleComReqDto)/*vcase invoke isSameApp*/;



List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    if(analysisReferenceTimeSecondCycleComRespDto !=null){
    QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq=new QuerySubCycleExecuteCycleStageListReq();
  querySubCycleExecuteCycleStageListReq.setIsProcessCycleStage("TRUE");//sourceId:1658663_1_64974
querySubCycleExecuteCycleStageListReq.setRelateContentTypeCode("TARGET");//sourceId:1653393_1_64974
if(analysisReferenceTimeSecondCycleComRespDto!=null){
      querySubCycleExecuteCycleStageListReq.setCycleEndTime(analysisReferenceTimeSecondCycleComRespDto.getComTimeField());//SimpleFieldAssign//sourceId:1653390_1_64974
    }
if(reqDto!=null){
      querySubCycleExecuteCycleStageListReq.setCycleTypeCode(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:1653391_1_64974
querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1653394_1_64974
    }

    /*3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）[4718]   */
    Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-周期结束时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleTypeCode(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-周期类型标识不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getIsProcessCycleStage(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-是否过程周期阶段不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getRelateContentTypeCode(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-关联目标内容类型编码不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      listString = listOmsExecuteCycleStage.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1653395_1_64975
    }

    /*3-3-07批量删执行周期阶段[2743]   */

      bOOLEAN = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 =new ArrayList<>();
    if(analysisReferenceTimeSecondCycleComRespDto !=null){
    QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq_1=new QuerySubCycleExecuteCycleStageListReq();
  querySubCycleExecuteCycleStageListReq_1.setIsProcessCycleStage("TRUE");//sourceId:1658663_1_64976
querySubCycleExecuteCycleStageListReq_1.setRelateContentTypeCode("TARGET");//sourceId:1653393_1_64976
if(analysisReferenceTimeSecondCycleComRespDto!=null){
      querySubCycleExecuteCycleStageListReq_1.setCycleEndTime(analysisReferenceTimeSecondCycleComRespDto.getComTimeField());//SimpleFieldAssign//sourceId:1653390_1_64976
    }
if(reqDto!=null){
      querySubCycleExecuteCycleStageListReq_1.setCycleTypeCode(reqDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1653391_1_64976
querySubCycleExecuteCycleStageListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1653394_1_64976
    }

    /*3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）[4718]   */
    Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getCycleEndTime(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-周期结束时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getCycleTypeCode(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-周期类型标识不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getIsProcessCycleStage(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-是否过程周期阶段不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getRelateContentTypeCode(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-关联目标内容类型编码不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_1.getEvaluationTemplateId(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往非末级过程执行周期列表（结束时间≤当前时间）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_1 ;
    if(listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&& listOmsExecuteCycleStage_2.size()>0 ){
          List<OmsExecuteCycleStage> listOmsExecuteCycleStage_3=new ArrayList<>();
  if(listOmsExecuteCycleStage_2!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&&  listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)){
      listOmsExecuteCycleStage_3 = //objList-to-objLists
        listOmsExecuteCycleStage_2.stream().map(item -> {
      OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
      elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:317653_2_64977
elm.setIsLastCycle("TRUE");//sourceId:317667_2_64977
elm.setNextCyclePeriod("---");//NULL//sourceId:317668_2_64977
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:317655_2_64977
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:317656_2_64977
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1653396_1_64977
    }

    /*3-3-07批量改执行周期阶段[3150]   */

      bOOLEAN_1 = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_3)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE"))){
       //elseif(D3执行过往执行周期是否末级处理(公共).周期模式类型编码 等于 父子周期)  64973

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleEqualStartAndGreaterDetailReq queryEvaObjTargetCycleEqualStartAndGreaterDetailReq=new QueryEvaObjTargetCycleEqualStartAndGreaterDetailReq();
  queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1762167_1_67643
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1762168_1_67643
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1762169_1_67643
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsSubCycle("TRUE");//sourceId:1762170_1_67643
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1762171_1_67643
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1762172_1_67643
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsArchive("FALSE");//sourceId:1762174_1_67643
if(reqDto!=null){
      queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1762173_1_67643
    }

    /*3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）[9460]   */
    Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getEvaObjEntityId(),"D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getEvaObjTypeCode(),"D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getTargetCycleContentTypeCode(),"D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getCycleStartTime(),"D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-目标计划开始时间不能为空",false);
Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getCycleEndTime(),"D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-目标计划结束时间不能为空",false);
Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getEvaluationTemplateId(),"D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.getIsArchive(),"D3执行过往执行周期是否末级处理(公共)-3-3-09查目标的当前子周期开始时间（开始时间≤当前时间≥结束时间）-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleEqualStartAndGreaterDetail(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq)/*vcase invoke 本地 method 方法调用;*/;



List<OmsExecuteCycleStage> listOmsExecuteCycleStage_4 =new ArrayList<>();
    if(omsEvaluationObjectTargetCycle !=null){
          QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq_2=new QuerySubCycleExecuteCycleStageListReq();
  querySubCycleExecuteCycleStageListReq_2.setIsProcessCycleStage("TRUE");//sourceId:1653497_1_64978
querySubCycleExecuteCycleStageListReq_2.setRelateContentTypeCode("TARGET");//sourceId:1653498_1_64978
if(omsEvaluationObjectTargetCycle!=null){
      querySubCycleExecuteCycleStageListReq_2.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1653496_1_64978
    }
if(reqDto!=null){
      querySubCycleExecuteCycleStageListReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1653499_1_64978
    }

    /*3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）[4718]   */
    Assert.isNull(querySubCycleExecuteCycleStageListReq_2.getCycleEndTime(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）-周期结束时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_2.getIsProcessCycleStage(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）-是否过程周期阶段不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_2.getRelateContentTypeCode(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）-关联目标内容类型编码不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_2.getEvaluationTemplateId(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查询过往过程执行周期阶段列表（结束时间≤当前年开始时间）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage_4 = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_2 ;
    if(listOmsExecuteCycleStage_4 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4)&& listOmsExecuteCycleStage_4.size()>0 ){
          List<String> listString_1=new ArrayList<>();
  if(listOmsExecuteCycleStage_4!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4)&&  listOmsExecuteCycleStage_4 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4)){
      listString_1 = listOmsExecuteCycleStage_4.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1653395_1_64979
    }

    /*3-3-07批量删执行周期阶段[2743]   */

      bOOLEAN_2 = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString_1)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsExecuteCycleStage> listOmsExecuteCycleStage_6 =new ArrayList<>();
    if(omsEvaluationObjectTargetCycle !=null){
          QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq_3=new QuerySubCycleExecuteCycleStageListReq();
  querySubCycleExecuteCycleStageListReq_3.setIsSubCycle("TRUE");//sourceId:1653522_1_64982
querySubCycleExecuteCycleStageListReq_3.setIsProcessCycleStage("FALSE");//sourceId:1653523_1_64982
querySubCycleExecuteCycleStageListReq_3.setRelateContentTypeCode("TARGET");//sourceId:1653524_1_64982
if(omsEvaluationObjectTargetCycle!=null){
      querySubCycleExecuteCycleStageListReq_3.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1653521_1_64982
    }
if(reqDto!=null){
      querySubCycleExecuteCycleStageListReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1653525_1_64982
    }

    /*3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）[4718]   */
    Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getCycleEndTime(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-周期结束时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getIsSubCycle(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-是否子周期不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getIsProcessCycleStage(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-是否过程周期阶段不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getRelateContentTypeCode(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-关联目标内容类型编码不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq_3.getEvaluationTemplateId(),"D3执行过往执行周期是否末级处理(公共)-3-3-07查过往子周期执行周期阶段列表（结束时间≤当前年开始时间）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage_6 = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq_3)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_3 ;
    if(listOmsExecuteCycleStage_6 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6)&& listOmsExecuteCycleStage_6.size()>0 ){
          List<OmsExecuteCycleStage> listOmsExecuteCycleStage_8=new ArrayList<>();
  if(listOmsExecuteCycleStage_6!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6)&&  listOmsExecuteCycleStage_6 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6)){
      listOmsExecuteCycleStage_8 = //objList-to-objLists
        listOmsExecuteCycleStage_6.stream().map(item -> {
      OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
      elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:317653_2_64983
elm.setIsLastCycle("TRUE");//sourceId:317667_2_64983
elm.setNextCyclePeriod("---");//NULL//sourceId:317668_2_64983
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:317655_2_64983
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:317656_2_64983
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1653396_1_64983
    }

    /*3-3-07批量改执行周期阶段[3150]   */

      bOOLEAN_3 = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_8)/*vcase invoke 本地 method 方法调用;*/;



           }
    }
      }
ImplementWhetherPastExecutionPeriodIsLastDisposeComRespDto retData = new ImplementWhetherPastExecutionPeriodIsLastDisposeComRespDto();





return retData;
  }
/**
   * D3分析上一个执行周期的周期及目标周期(公共)[9585]
   * gen by moon at 5/23/2024, 7:16:39 PM
   */
  @Trace(operationName = "D3分析上一个执行周期的周期及目标周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisLastExecCycleAndTargetCycleComRespDto analysisLastExecCycleAndTargetCycleCom(AnalysisLastExecCycleAndTargetCycleComReqDto reqDto){


      QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto_1 =null;
if((reqDto!= null&& reqDto.getEvaObjTargetCycleId() != null )) {
        //if(D3分析上一个执行周期的周期及目标周期(公共).被评对象目标周期ID 值不等于空 )  68467

QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
    QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto=new QueryLastExecCycleAndTargetCycleDetailComReqDto();
  if(reqDto!=null){
      queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1801677_1_68468
queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1801678_1_68468
queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1801679_1_68468
    }

    /*D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]   */
    Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(),"D3分析上一个执行周期的周期及目标周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(),"D3分析上一个执行周期的周期及目标周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(),"D3分析上一个执行周期的周期及目标周期(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-冗余评价模板ID不能为空",false);
      queryLastExecCycleAndTargetCycleDetailComRespDto = queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto)/*vcase invoke 同服务,同domain*/;


      queryLastExecCycleAndTargetCycleDetailComRespDto_1 = queryLastExecCycleAndTargetCycleDetailComRespDto;
      }
AnalysisLastExecCycleAndTargetCycleComRespDto retData = new AnalysisLastExecCycleAndTargetCycleComRespDto();
  if(queryLastExecCycleAndTargetCycleDetailComRespDto_1!=null){
      retData.setLastEvaObjTargetCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1801814_1
retData.setEvaObjEntityId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815762_1
retData.setEvaObjTypeCode(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815763_1
    }




return retData;
  }
/**
   * D3执行周期查询条件分析(公共)[9659]
   * gen by moon at 5/26/2024, 8:05:11 PM
   */
  @Trace(operationName = "D3执行周期查询条件分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementExecuteCycleConditionsComRespDto implementExecuteCycleConditionsCom(ImplementExecuteCycleConditionsComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getCycleTypeCode() !=null && reqDto.getCycleTypeCode().equals("WEEK")||reqDto!= null&&  reqDto.getCycleTypeCode() !=null && reqDto.getCycleTypeCode().equals("DOUBLE_WEEKS"))) {
        //if((D3执行周及双周执行周期查询条件分析(公共).更新周期周期类型 等于 周 or D3执行周及双周执行周期查询条件分析(公共).更新周期周期类型 等于 双周))  69073

if((reqDto!= null&&  reqDto.getIsOpenCustomExecuteCycle() !=null && reqDto.getIsOpenCustomExecuteCycle().equals("TRUE"))) {
        //if(D3执行周及双周执行周期查询条件分析(公共).是否开启自定义执行周期 等于 是)  69076

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817492_1_69078
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817493_1_69078
    }

    /*M3-接收出参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3执行周期查询条件分析(公共)-M3-接收出参字段-关联目标内容ID不能为空",false);
      receptionServiceRes = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((reqDto!= null&&  reqDto.getIsOpenCustomExecuteCycle() !=null && reqDto.getIsOpenCustomExecuteCycle().equals("FALSE"))){
       //elseif(D3执行周及双周执行周期查询条件分析(公共).是否开启自定义执行周期 等于 否)  69077

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1817599_1_69086
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1817600_1_69086
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1817604_1_69086
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817601_1_69086
queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getOwnWorkCycleId());//SimpleFieldAssign//sourceId:1817602_1_69086
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817603_1_69086
    }

    /*3-3-09查目标的被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(),"D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行周期查询条件分析(公共)-3-3-09查目标的被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      receptionServiceReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817492_1_69079
    }
if(reqDto!=null){
      receptionServiceReq_1.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817493_1_69079
    }

    /*M3-接收出参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTargetCycleContentId(),"D3执行周期查询条件分析(公共)-M3-接收出参字段-关联目标内容ID不能为空",false);
      receptionServiceRes_2 = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
else{
       //else  69087

//异常结束 69088
      throw new BizException("220100444","对不起，目标内容的自定义执行周期数据异常~",false);
    }
      }
else if((!(reqDto!= null&&  reqDto.getCycleTypeCode() !=null && reqDto.getCycleTypeCode().equals("WEEK"))&&!(reqDto!= null&&  reqDto.getCycleTypeCode() !=null && reqDto.getCycleTypeCode().equals("DOUBLE_WEEKS")))){
       //elseif((D3执行周及双周执行周期查询条件分析(公共).更新周期周期类型 不等于 周 and D3执行周及双周执行周期查询条件分析(公共).更新周期周期类型 不等于 双周))  69074

if((reqDto!= null&&  reqDto.getIsOpenCustomExecuteCycle() !=null && reqDto.getIsOpenCustomExecuteCycle().equals("TRUE"))) {
        //if(D3执行周及双周执行周期查询条件分析(公共).是否开启自定义执行周期 等于 是)  69081

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_2.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817493_1_69083
    }

    /*M3-接收出参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTargetCycleContentId(),"D3执行周期查询条件分析(公共)-M3-接收出参字段-关联目标内容ID不能为空",false);
      receptionServiceRes_3 = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
      }
else if((reqDto!= null&&  reqDto.getIsOpenCustomExecuteCycle() !=null && reqDto.getIsOpenCustomExecuteCycle().equals("FALSE"))){
       //elseif(D3执行周及双周执行周期查询条件分析(公共).是否开启自定义执行周期 等于 否)  69082

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_3=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_3.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817493_1_69084
    }

    /*M3-接收出参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTargetCycleContentId(),"D3执行周期查询条件分析(公共)-M3-接收出参字段-关联目标内容ID不能为空",false);
      receptionServiceRes_4 = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_1 = receptionServiceRes_4;
    }
else{
       //else  69089

//异常结束 69090
      throw new BizException("220100444","对不起，目标内容的自定义执行周期数据异常~",false);
    }
    }
else{
       //else  69092

//异常结束 69093
      throw new BizException("220100445","对不起，更新周期的周期类型数据异常~",false);
    }
ImplementExecuteCycleConditionsComRespDto retData = new ImplementExecuteCycleConditionsComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setEvaObjTargetCycleId(receptionServiceRes_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817695_1
retData.setTargetCycleContentId(receptionServiceRes_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817696_1
    }




return retData;
  }
/**
   * D3查询目标内容执行周期详情(公共)[9661]
   * gen by moon at 6/6/2024, 4:20:33 PM
   */
  @Trace(operationName = "D3查询目标内容执行周期详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContexeCuteCycleDetailComRespDto queryTargetContexeCuteCycleDetailCom(QueryTargetContexeCuteCycleDetailComReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
      QueryProcExecuteCycleStageDetailComRespDto queryProcExecuteCycleStageDetailComRespDto_1=null;
      //步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817884_1
receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1818005_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817886_1
    }

    /*M3-接收入参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3查询目标内容执行周期详情(公共)-M3-接收入参字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleId(),"D3查询目标内容执行周期详情(公共)-M3-接收入参字段-周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询目标内容执行周期详情(公共)-M3-接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbExecuteCycle.implementElevenReceivingField(receptionServiceReq);




//步骤1: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1817979_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817977_1
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817978_1
    }

    /*3-3-09查入参目标周期详情（获取工作周期ID及目标内容ID、目标ID）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3查询目标内容执行周期详情(公共)-3-3-09查入参目标周期详情（获取工作周期ID及目标内容ID、目标ID）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3查询目标内容执行周期详情(公共)-3-3-09查入参目标周期详情（获取工作周期ID及目标内容ID、目标ID）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3查询目标内容执行周期详情(公共)-3-3-09查入参目标周期详情（获取工作周期ID及目标内容ID、目标ID）-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;

//步骤2: D3准备目标内容扩展信息(公共) - preparationTargetContExtendInfoCom
     PreparationTargetContExtendInfoComRespDto preparationTargetContExtendInfoComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          PreparationTargetContExtendInfoComReqDto preparationTargetContExtendInfoComReqDto=new PreparationTargetContExtendInfoComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      preparationTargetContExtendInfoComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817832_1
preparationTargetContExtendInfoComReqDto.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1817833_1
    }
if(reqDto!=null){
      preparationTargetContExtendInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817834_1
    }

    /*D3查询目标内容扩展信息（获取目标内容是否开启自定义执行周期）[8590]   */
    Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentId(),"D3查询目标内容执行周期详情(公共)-D3查询目标内容扩展信息（获取目标内容是否开启自定义执行周期）-关联目标内容ID不能为空",false);
Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentTypeCode(),"D3查询目标内容执行周期详情(公共)-D3查询目标内容扩展信息（获取目标内容是否开启自定义执行周期）-关联目标内容类型编码不能为空",false);
Assert.isNull(preparationTargetContExtendInfoComReqDto.getEvaluationTemplateId(),"D3查询目标内容执行周期详情(公共)-D3查询目标内容扩展信息（获取目标内容是否开启自定义执行周期）-冗余评价模板ID不能为空",false);
      preparationTargetContExtendInfoComRespDto = targetCalcService.preparationTargetContExtendInfoCom(preparationTargetContExtendInfoComReqDto)/*vcase invoke isSameApp*/;



           }

//步骤3: 3-4-04查询周期详情 - queryCycleDetail
     OmsCycle omsCycle = null;
    QueryCycleDetailReq queryCycleDetailReq=new QueryCycleDetailReq();
  queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1820348_1
if(reqDto!=null){
      queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1820347_1
    }

    /*3-4-04查询周期详情（获取周期类型标识）[2004]   */
    Assert.isNull(queryCycleDetailReq.getCycleId(),"D3查询目标内容执行周期详情(公共)-3-4-04查询周期详情（获取周期类型标识）-周期ID不能为空",false);
Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(),"D3查询目标内容执行周期详情(公共)-3-4-04查询周期详情（获取周期类型标识）-主体生命周期不能为空",false);
      omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤4: D3执行周期查询条件分析(公共) - implementExecuteCycleConditionsCom
     ImplementExecuteCycleConditionsComRespDto implementExecuteCycleConditionsComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementExecuteCycleConditionsComReqDto implementExecuteCycleConditionsComReqDto=new ImplementExecuteCycleConditionsComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      implementExecuteCycleConditionsComReqDto.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1817988_1
implementExecuteCycleConditionsComReqDto.setOwnWorkCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1817986_1
implementExecuteCycleConditionsComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817987_1
    }
if(omsCycle!=null){
      implementExecuteCycleConditionsComReqDto.setCycleTypeCode(omsCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1817842_1
    }
if(reqDto!=null){
implementExecuteCycleConditionsComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817844_1
implementExecuteCycleConditionsComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817843_1
    }
if(preparationTargetContExtendInfoComRespDto!=null){
      implementExecuteCycleConditionsComReqDto.setIsOpenCustomExecuteCycle(preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle());//SimpleFieldAssign//sourceId:1817847_1
    }

    /*D3执行周期查询条件分析(公共)[9659]   */
    Assert.isNull(implementExecuteCycleConditionsComReqDto.getTargetId(),"D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementExecuteCycleConditionsComReqDto.getCycleTypeCode(),"D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-周期类型标识不能为空",false);
Assert.isNull(implementExecuteCycleConditionsComReqDto.getOwnWorkCycleId(),"D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-归属工作周期ID不能为空",false);
Assert.isNull(implementExecuteCycleConditionsComReqDto.getEvaObjTargetCycleId(),"D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementExecuteCycleConditionsComReqDto.getTargetCycleContentId(),"D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementExecuteCycleConditionsComReqDto.getIsOpenCustomExecuteCycle(),"D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-是否开启自定义执行周期不能为空",false);
Assert.isNull(implementExecuteCycleConditionsComReqDto.getEvaluationTemplateId(),"D3查询目标内容执行周期详情(公共)-D3执行周期查询条件分析(公共)-冗余评价模板ID不能为空",false);
      implementExecuteCycleConditionsComRespDto = implementExecuteCycleConditionsCom(implementExecuteCycleConditionsComReqDto)/*vcase invoke 同服务,同domain*/;



           }

//步骤5: D3-查询过程周期执行周期阶段详情(公共) - queryProcExecuteCycleStageDetailCom
     QueryProcExecuteCycleStageDetailComRespDto queryProcExecuteCycleStageDetailComRespDto = null;
    if(implementExecuteCycleConditionsComRespDto !=null){
          QueryProcExecuteCycleStageDetailComReqDto queryProcExecuteCycleStageDetailComReqDto=new QueryProcExecuteCycleStageDetailComReqDto();
  queryProcExecuteCycleStageDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1817995_1
if(reqDto!=null){
      queryProcExecuteCycleStageDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1817989_1
queryProcExecuteCycleStageDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817991_1
    }
if(implementExecuteCycleConditionsComRespDto!=null){
      queryProcExecuteCycleStageDetailComReqDto.setRelateContentId(implementExecuteCycleConditionsComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817990_1
queryProcExecuteCycleStageDetailComReqDto.setEvaObjTargetCycleId(implementExecuteCycleConditionsComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1817994_1
    }

    /*D3-查询执行周期阶段详情(公共)[6645]   */
    Assert.isNull(queryProcExecuteCycleStageDetailComReqDto.getCycleId(),"D3查询目标内容执行周期详情(公共)-D3-查询执行周期阶段详情(公共)-周期ID不能为空",false);
Assert.isNull(queryProcExecuteCycleStageDetailComReqDto.getRelateContentId(),"D3查询目标内容执行周期详情(公共)-D3-查询执行周期阶段详情(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryProcExecuteCycleStageDetailComReqDto.getEvaluationTemplateId(),"D3查询目标内容执行周期详情(公共)-D3-查询执行周期阶段详情(公共)-评价模板ID不能为空",false);
Assert.isNull(queryProcExecuteCycleStageDetailComReqDto.getSubjectLifeCycle(),"D3查询目标内容执行周期详情(公共)-D3-查询执行周期阶段详情(公共)-主体生命周期不能为空",false);
      queryProcExecuteCycleStageDetailComRespDto = targetCycleService.queryProcExecuteCycleStageDetailCom(queryProcExecuteCycleStageDetailComReqDto)/*vcase invoke isSameApp*/;


        queryProcExecuteCycleStageDetailComRespDto_1 = queryProcExecuteCycleStageDetailComRespDto;
           }

QueryTargetContexeCuteCycleDetailComRespDto retData = new QueryTargetContexeCuteCycleDetailComRespDto();


      if(queryProcExecuteCycleStageDetailComRespDto_1!=null){
      retData.setExecuteCycleStageId(queryProcExecuteCycleStageDetailComRespDto_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1818960_1
retData.setLastExecuteCycleStageId(queryProcExecuteCycleStageDetailComRespDto_1.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1818961_1
retData.setRelateExecuteCycleStageId(queryProcExecuteCycleStageDetailComRespDto_1.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1818962_1
retData.setEvaObjTargetCycleId(queryProcExecuteCycleStageDetailComRespDto_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1818963_1
retData.setCycleId(queryProcExecuteCycleStageDetailComRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:1818964_1
retData.setCycleStandardName(queryProcExecuteCycleStageDetailComRespDto_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1818965_1
retData.setCycleStartTime(queryProcExecuteCycleStageDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1818966_1
retData.setCycleEndTime(queryProcExecuteCycleStageDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1818967_1
retData.setCycleTypeCode(queryProcExecuteCycleStageDetailComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1818968_1
retData.setIsFatherCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsFatherCycle());//SimpleFieldAssign//sourceId:1818969_1
retData.setIsMetaphase(queryProcExecuteCycleStageDetailComRespDto_1.getIsMetaphase());//SimpleFieldAssign//sourceId:1818970_1
retData.setIsSubCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsSubCycle());//SimpleFieldAssign//sourceId:1818971_1
retData.setIsProcessCycleStage(queryProcExecuteCycleStageDetailComRespDto_1.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1818972_1
retData.setIsLastCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1818973_1
retData.setIsDefinedExecuteCycleStage(queryProcExecuteCycleStageDetailComRespDto_1.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1818974_1
retData.setNextCyclePeriod(queryProcExecuteCycleStageDetailComRespDto_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1818975_1
retData.setFillStartTime(queryProcExecuteCycleStageDetailComRespDto_1.getFillStartTime());//SimpleFieldAssign//sourceId:1818976_1
retData.setFillEndtTime(queryProcExecuteCycleStageDetailComRespDto_1.getFillEndtTime());//SimpleFieldAssign//sourceId:1818977_1
retData.setIsNextCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsNextCycle());//SimpleFieldAssign//sourceId:1818978_1
retData.setIsCurrentCycle(queryProcExecuteCycleStageDetailComRespDto_1.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1818979_1
retData.setOrderNumber(queryProcExecuteCycleStageDetailComRespDto_1.getOrderNumber());//SimpleFieldAssign//sourceId:1818980_1
retData.setEvaTempCreateTime(queryProcExecuteCycleStageDetailComRespDto_1.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1818981_1
retData.setRelateContentTypeCode(queryProcExecuteCycleStageDetailComRespDto_1.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1818982_1
retData.setRelateContentId(queryProcExecuteCycleStageDetailComRespDto_1.getRelateContentId());//SimpleFieldAssign//sourceId:1818983_1
retData.setTargetId(queryProcExecuteCycleStageDetailComRespDto_1.getTargetId());//SimpleFieldAssign//sourceId:1818984_1
retData.setEvaluationTemplateId(queryProcExecuteCycleStageDetailComRespDto_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1818985_1
      }
if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1852097_1
    }




return retData;
  }
/**
   * D3查询执行周期阶段（时间从小到大）列表(公共)[9714]
   * gen by moon at 6/2/2024, 10:50:01 PM
   */
  @Trace(operationName = "D3查询执行周期阶段（时间从小到大）列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryExecuteCycleByTimeBigtoSmallListComRespDto queryExecuteCycleByTimeBigtoSmallListCom(QueryExecuteCycleByTimeBigtoSmallListComReqDto reqDto){


      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 =new ArrayList<>();
//步骤0: 3-3-07查询执行周期阶段（时间从小到大）列表 - queryExecuteCycleByTimeBigtoSmallList
     List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleByTimeBigtoSmallListReq queryExecuteCycleByTimeBigtoSmallListReq=new QueryExecuteCycleByTimeBigtoSmallListReq();
  if(reqDto!=null){
      queryExecuteCycleByTimeBigtoSmallListReq.setRelateContentId(reqDto.getRelateContentId());//SimpleFieldAssign//sourceId:1840917_1
queryExecuteCycleByTimeBigtoSmallListReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1840922_1
queryExecuteCycleByTimeBigtoSmallListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1840918_1
queryExecuteCycleByTimeBigtoSmallListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1840919_1
queryExecuteCycleByTimeBigtoSmallListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1840920_1
    }

    /*3-3-07查询执行周期阶段（时间从小到大）列表[8594]   */
    Assert.isNull(queryExecuteCycleByTimeBigtoSmallListReq.getSpaceId(),"D3查询执行周期阶段（时间从小到大）列表(公共)-3-3-07查询执行周期阶段（时间从小到大）列表-创建于空间ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleByTimeBigtoSmallList(queryExecuteCycleByTimeBigtoSmallListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

QueryExecuteCycleByTimeBigtoSmallListComRespDto retData = new QueryExecuteCycleByTimeBigtoSmallListComRespDto();
  retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1840928_1




return retData;
  }
/**
   * D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）[7506]
   * gen by moon at 6/23/2024, 2:26:52 AM
   */
  @Trace(operationName = "D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryExecuteCycleBigStartLessEndDetailComRespDto queryExecuteCycleBigStartLessEndDetailCom(QueryExecuteCycleBigStartLessEndDetailComReqDto reqDto){


      OmsExecuteCycleStage omsExecuteCycleStage_1 =null;
//步骤0: 3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于） - queryExecuteCycleBigStartLessEndDetail
     OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleBigStartLessEndDetailReq queryExecuteCycleBigStartLessEndDetailReq=new QueryExecuteCycleBigStartLessEndDetailReq();
  queryExecuteCycleBigStartLessEndDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1165583_1
if(reqDto!=null){
      queryExecuteCycleBigStartLessEndDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1887391_1
queryExecuteCycleBigStartLessEndDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887392_1
queryExecuteCycleBigStartLessEndDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887393_1
//queryExecuteCycleBigStartLessEndDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887395_1
queryExecuteCycleBigStartLessEndDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1165582_1
    }

    /*3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）[7505]   */
    Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getCycleStartTime(),"D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getCycleEndTime(),"D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getCycleTypeCode(),"D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-周期类型标识不能为空",false);
//Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getEvaObjTargetCycleId(),"D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getEvaluationTemplateId(),"D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndDetailReq.getSubjectLifeCycle(),"D3查工作周期范围内执行周期详情（开始大于等于&结束小于等于）-3-3-07查执行周期时间范围详情（开始小于等于&结束大于等于）-主体生命周期不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleBigStartLessEndDetail(queryExecuteCycleBigStartLessEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsExecuteCycleStage_1 = omsExecuteCycleStage;

QueryExecuteCycleBigStartLessEndDetailComRespDto retData = new QueryExecuteCycleBigStartLessEndDetailComRespDto();
  if(omsExecuteCycleStage_1!=null){
      retData.setCycleStartTime(omsExecuteCycleStage_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1887405_1
retData.setCycleEndTime(omsExecuteCycleStage_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1887406_1
    }




return retData;
  }
/**
   * D3查询执行周期阶段列表（开始大于等于&结束小于等于）[9850]
   * gen by moon at 7/10/2024, 6:45:21 PM
   */
  @Trace(operationName = "D3查询执行周期阶段列表（开始大于等于&结束小于等于）")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryExecuteCycleBigStartLessEndListComRespDto queryExecuteCycleBigStartLessEndListCom(QueryExecuteCycleBigStartLessEndListComReqDto reqDto){


      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 =new ArrayList<>();
//步骤0: 3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于） - querySubCycleExecuteCycleStageList
     List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq=new QuerySubCycleExecuteCycleStageListReq();
  if(reqDto!=null){
      querySubCycleExecuteCycleStageListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1887268_1
querySubCycleExecuteCycleStageListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887269_1
querySubCycleExecuteCycleStageListReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887270_1
querySubCycleExecuteCycleStageListReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887288_1
querySubCycleExecuteCycleStageListReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1925278_1
querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887279_1
querySubCycleExecuteCycleStageListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1887286_1
    }

    /*3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）[4718]   */
    Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleStartTime(),"D3查询执行周期阶段列表（开始大于等于&结束小于等于）-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(),"D3查询执行周期阶段列表（开始大于等于&结束小于等于）-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(),"D3查询执行周期阶段列表（开始大于等于&结束小于等于）-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getSubjectLifeCycle(),"D3查询执行周期阶段列表（开始大于等于&结束小于等于）-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-主体生命周期不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

QueryExecuteCycleBigStartLessEndListComRespDto retData = new QueryExecuteCycleBigStartLessEndListComRespDto();
  retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887303_1




return retData;
  }
/**
   * D3查询执行周期阶段列表（开始小于等于&结束大于等于）[9851]
   * gen by moon at 7/10/2024, 6:45:28 PM
   */
  @Trace(operationName = "D3查询执行周期阶段列表（开始小于等于&结束大于等于）")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryExecuteCycleLessStartBIgEndListComRespDto queryExecuteCycleLessStartBIgEndListCom(QueryExecuteCycleLessStartBIgEndListComReqDto reqDto){


      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 =new ArrayList<>();
//步骤0: 3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于） - queryExecuteCycleLessStartBIgEndList
     List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleLessStartBIgEndListReq queryExecuteCycleLessStartBIgEndListReq=new QueryExecuteCycleLessStartBIgEndListReq();
  if(reqDto!=null){
      queryExecuteCycleLessStartBIgEndListReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887356_1
queryExecuteCycleLessStartBIgEndListReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1925282_1
queryExecuteCycleLessStartBIgEndListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1887357_1
queryExecuteCycleLessStartBIgEndListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887358_1
queryExecuteCycleLessStartBIgEndListReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887434_1
queryExecuteCycleLessStartBIgEndListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887359_1
queryExecuteCycleLessStartBIgEndListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1887360_1
    }

    /*3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）[7222]   */
Assert.isNull(queryExecuteCycleLessStartBIgEndListReq.getCycleStartTime(),"D3查询执行周期阶段列表（开始小于等于&结束大于等于）-3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBIgEndListReq.getCycleEndTime(),"D3查询执行周期阶段列表（开始小于等于&结束大于等于）-3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBIgEndListReq.getEvaluationTemplateId(),"D3查询执行周期阶段列表（开始小于等于&结束大于等于）-3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBIgEndListReq.getSubjectLifeCycle(),"D3查询执行周期阶段列表（开始小于等于&结束大于等于）-3-3-07时间范围查询执行周期列表（开始小于等于&结束大于等于）-主体生命周期不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleLessStartBIgEndList(queryExecuteCycleLessStartBIgEndListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

QueryExecuteCycleLessStartBIgEndListComRespDto retData = new QueryExecuteCycleLessStartBIgEndListComRespDto();
  retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887367_1




return retData;
  }
/**
   * D3查询执行周期阶段列表(公共)[9854]
   * gen by moon at 8/26/2024, 1:18:44 PM
   */
  @Trace(operationName = "D3查询执行周期阶段列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryExecuteCycleByEvaTempListComRespDto queryExecuteCycleByEvaTempListCom(QueryExecuteCycleByEvaTempListComReqDto reqDto){


      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 =new ArrayList<>();
//步骤0: 3-3-07查询执行周期阶段列表 - queryExecuteCycleStageTestList
     List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleStageTestListReq queryExecuteCycleStageTestListReq=new QueryExecuteCycleStageTestListReq();
  if(reqDto!=null){
      queryExecuteCycleStageTestListReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887527_1
queryExecuteCycleStageTestListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887525_1
queryExecuteCycleStageTestListReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1887536_1
queryExecuteCycleStageTestListReq.setRelateContentTypeCode(reqDto.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1925275_1
queryExecuteCycleStageTestListReq.setRelateContentId(reqDto.getRelateContentId());//SimpleFieldAssign//sourceId:1933263_1
queryExecuteCycleStageTestListReq.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1988286_1
queryExecuteCycleStageTestListReq.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1933265_1
queryExecuteCycleStageTestListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887522_1
queryExecuteCycleStageTestListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1887528_1
queryExecuteCycleStageTestListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1887518_1
    }

    /*3-3-07查询执行周期阶段列表[4288]   */
    Assert.isNull(queryExecuteCycleStageTestListReq.getSubjectLifeCycle(),"D3查询执行周期阶段列表(公共)-3-3-07查询执行周期阶段列表-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq.getSpaceId(),"D3查询执行周期阶段列表(公共)-3-3-07查询执行周期阶段列表-创建于空间ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageTestList(queryExecuteCycleStageTestListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

QueryExecuteCycleByEvaTempListComRespDto retData = new QueryExecuteCycleByEvaTempListComRespDto();
  retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887538_1




return retData;
    }
/**
   * D3批量查询执行周期阶段列表ByIds(公共)[9852]
   * gen by moon at 7/10/2024, 9:44:28 PM
   */
  @Trace(operationName = "D3批量查询执行周期阶段列表ByIds(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryExecuteCycleByEvaTempListByIdsComRespDto batchQueryExecuteCycleByEvaTempListByIdsCom(BatchQueryExecuteCycleByEvaTempListByIdsComReqDto reqDto){


      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 =new ArrayList<>();
//步骤0: 3-3-07批量查执行周期列表（by执行周期ID） - batchQueryTargetCycleList
     List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    BatchQueryTargetCycleListReq batchQueryTargetCycleListReq=new BatchQueryTargetCycleListReq();
  batchQueryTargetCycleListReq.setIsArchive("FALSE");//sourceId:1887440_1
if(reqDto!=null){
      batchQueryTargetCycleListReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList());//list-field-assign//sourceId:1887438_1
batchQueryTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887442_1
batchQueryTargetCycleListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1887441_1
    }

    /*3-3-07批量查执行周期列表（by执行周期ID）[2194]   */
    Assert.isNull(batchQueryTargetCycleListReq.getEvaluationTemplateId(),"D3批量查询执行周期阶段列表ByIds(公共)-3-3-07批量查执行周期列表（by执行周期ID）-评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetCycleListReq.getSubjectLifeCycle(),"D3批量查询执行周期阶段列表ByIds(公共)-3-3-07批量查执行周期列表（by执行周期ID）-主体生命周期不能为空",false);
Assert.isNull(batchQueryTargetCycleListReq.getIsArchive(),"D3批量查询执行周期阶段列表ByIds(公共)-3-3-07批量查执行周期列表（by执行周期ID）-是否存档不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryTargetCycleList(batchQueryTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

BatchQueryExecuteCycleByEvaTempListByIdsComRespDto retData = new BatchQueryExecuteCycleByEvaTempListByIdsComRespDto();
  retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887446_1




return retData;
  }
/**
   * D3批量查询执行周期阶段By内容ID列表(公共)[9963]
   * gen by moon at 7/14/2024, 11:03:13 PM
   */
  @Trace(operationName = "D3批量查询执行周期阶段By内容ID列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryExecuteCycleByContIdListByIdsComRespDto batchQueryExecuteCycleByContIdListByIdsCom(BatchQueryExecuteCycleByContIdListByIdsComReqDto reqDto){


      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_1 =new ArrayList<>();
//步骤0: 3-3-07批量查询执行周期阶段By内容ID列表 - batchQueryExecuteCycleByContIdListByIds
     List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    BatchQueryExecuteCycleByContIdListByIdsReq batchQueryExecuteCycleByContIdListByIdsReq=new BatchQueryExecuteCycleByContIdListByIdsReq();
  if(reqDto!=null){
      batchQueryExecuteCycleByContIdListByIdsReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList());//list-field-assign//sourceId:1932892_1
batchQueryExecuteCycleByContIdListByIdsReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1932893_1
batchQueryExecuteCycleByContIdListByIdsReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1932894_1
batchQueryExecuteCycleByContIdListByIdsReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1932895_1
    }

    /*3-3-07批量查询执行周期阶段By内容ID列表[9962]   */

      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryExecuteCycleByContIdListByIds(batchQueryExecuteCycleByContIdListByIdsReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_1 = listOmsExecuteCycleStage;

BatchQueryExecuteCycleByContIdListByIdsComRespDto retData = new BatchQueryExecuteCycleByContIdListByIdsComRespDto();
  if(listOmsExecuteCycleStage_1!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_1)&&  listOmsExecuteCycleStage_1 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_1)){
      retData.setExecuteCycleStageList(listOmsExecuteCycleStage_1.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1932902_1
    }




return retData;
  }
/**
   * D3查询上一个执行周期的周期详情(公共)[9964]
   * gen by moon at 7/16/2024, 8:26:14 PM
   */
  @Trace(operationName = "D3查询上一个执行周期的周期详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryLastExecCycleDetailComRespDto queryLastExecCycleDetailCom(QueryLastExecCycleDetailComReqDto reqDto){


      OmsExecuteCycleStage omsExecuteCycleStage_1 =null;
if((reqDto!= null&& reqDto.getLastExecuteCycleStageId() != null )) {
        //if(D3查询上一个执行周期的周期详情(公共).上一执行周期阶段ID 值不等于空 )  71612

OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setExecuteCycleStageId(reqDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1934232_1_71613
queryExecuteCycleStageDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1934234_1_71613
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1934233_1_71613
queryExecuteCycleStageDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1934235_1_71613
    }

    /*3-3-07查询执行周期阶段详情[2429]   */

      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsExecuteCycleStage_1 = omsExecuteCycleStage;
      }
QueryLastExecCycleDetailComRespDto retData = new QueryLastExecCycleDetailComRespDto();
  if(omsExecuteCycleStage_1!=null){
      retData.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1934236_1
retData.setLastExecuteCycleStageId(omsExecuteCycleStage_1.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1934237_1
retData.setRelateExecuteCycleStageId(omsExecuteCycleStage_1.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1934238_1
retData.setEvaObjTargetCycleId(omsExecuteCycleStage_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1934239_1
retData.setCycleId(omsExecuteCycleStage_1.getCycleId());//SimpleFieldAssign//sourceId:1934240_1
retData.setCycleStandardName(omsExecuteCycleStage_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1934241_1
retData.setCycleTypeCode(omsExecuteCycleStage_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1934242_1
retData.setCycleTypeInstanceCode(omsExecuteCycleStage_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1934243_1
retData.setCycleStartTime(omsExecuteCycleStage_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1934244_1
retData.setCycleEndTime(omsExecuteCycleStage_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1934245_1
retData.setFillStartTime(omsExecuteCycleStage_1.getFillStartTime());//SimpleFieldAssign//sourceId:1934246_1
retData.setFillEndtTime(omsExecuteCycleStage_1.getFillEndtTime());//SimpleFieldAssign//sourceId:1934247_1
retData.setIsFatherCycle(omsExecuteCycleStage_1.getIsFatherCycle());//SimpleFieldAssign//sourceId:1934248_1
retData.setIsSubCycle(omsExecuteCycleStage_1.getIsSubCycle());//SimpleFieldAssign//sourceId:1934249_1
retData.setRelateContentTypeCode(omsExecuteCycleStage_1.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1934250_1
retData.setRelateContentId(omsExecuteCycleStage_1.getRelateContentId());//SimpleFieldAssign//sourceId:1934251_1
retData.setTargetId(omsExecuteCycleStage_1.getTargetId());//SimpleFieldAssign//sourceId:1934252_1
retData.setIsMetaphase(omsExecuteCycleStage_1.getIsMetaphase());//SimpleFieldAssign//sourceId:1934253_1
retData.setIsProcessCycleStage(omsExecuteCycleStage_1.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1934254_1
retData.setIsDefinedExecuteCycleStage(omsExecuteCycleStage_1.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1934255_1
retData.setIsLastCycle(omsExecuteCycleStage_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1934256_1
retData.setIsCurrentCycle(omsExecuteCycleStage_1.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1934257_1
retData.setIsNextCycle(omsExecuteCycleStage_1.getIsNextCycle());//SimpleFieldAssign//sourceId:1934258_1
retData.setNextCyclePeriod(omsExecuteCycleStage_1.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1934259_1
retData.setEvaluateStartTime(omsExecuteCycleStage_1.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1934260_1
retData.setEvaluateEndtTime(omsExecuteCycleStage_1.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1934261_1
retData.setIsStartCycle(omsExecuteCycleStage_1.getIsStartCycle());//SimpleFieldAssign//sourceId:1934262_1
retData.setIsEndCycle(omsExecuteCycleStage_1.getIsEndCycle());//SimpleFieldAssign//sourceId:1934263_1
retData.setIsSameSceneCurrentSubCycle(omsExecuteCycleStage_1.getIsSameSceneCurrentSubCycle());//SimpleFieldAssign//sourceId:1934264_1
retData.setEvaluationTemplateId(omsExecuteCycleStage_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1934265_1
retData.setOrderNumber(omsExecuteCycleStage_1.getOrderNumber());//SimpleFieldAssign//sourceId:1934266_1
retData.setEvaTempCreateTime(omsExecuteCycleStage_1.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1934267_1
    }




return retData;
  }
  //
}
